package com.chatmcp.mcprouter.service.impl;

import com.chatmcp.mcprouter.dto.ServerKeyDto;
import com.chatmcp.mcprouter.mapper.ServerKeyMapper;
import com.chatmcp.mcprouter.model.ServerKey;
import com.chatmcp.mcprouter.service.ServerKeyService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import java.util.stream.Collectors;

/**
 * 服务器密钥服务实现类
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class ServerKeyServiceImpl implements ServerKeyService {

    private final ServerKeyMapper serverKeyMapper;

    @Override
    public List<ServerKeyDto> getAllServerKeys() {
        List<ServerKey> serverKeys = serverKeyMapper.selectAll();
        return serverKeys.stream()
                .map(this::convertToDto)
                .collect(Collectors.toList());
    }

    @Override
    public ServerKeyDto getServerKeyById(Long id) {
        ServerKey serverKey = serverKeyMapper.selectById(id);
        return serverKey != null ? convertToDto(serverKey) : null;
    }

    @Override
    public ServerKeyDto getServerKeyByKey(String key) {
        ServerKey serverKey = serverKeyMapper.selectByKey(key);
        return serverKey != null ? convertToDto(serverKey) : null;
    }

    @Override
    public ServerKeyDto getServerKeyByServerUuid(String serverUuid) {
        ServerKey serverKey = serverKeyMapper.selectByServerUuid(serverUuid);
        return serverKey != null ? convertToDto(serverKey) : null;
    }

    @Override
    public ServerKeyDto createServerKey(ServerKeyDto serverKeyDto) {
        ServerKey serverKey = convertToEntity(serverKeyDto);
        
        // 设置创建和更新时间
        LocalDateTime now = LocalDateTime.now();
        serverKey.setCreatedAt(now);
        serverKey.setUpdatedAt(now);
        
        // 生成新的密钥
        if (serverKey.getKey() == null || serverKey.getKey().isEmpty()) {
            serverKey.setKey(generateUniqueKey());
        }
        
        // 生成服务器UUID
        if (serverKey.getServerUuid() == null || serverKey.getServerUuid().isEmpty()) {
            serverKey.setServerUuid(UUID.randomUUID().toString());
        }
        
        serverKeyMapper.insert(serverKey);
        
        return convertToDto(serverKey);
    }

    @Override
    public ServerKeyDto updateServerKey(Long id, ServerKeyDto serverKeyDto) {
        ServerKey existingServerKey = serverKeyMapper.selectById(id);
        if (existingServerKey == null) {
            return null;
        }

        ServerKey updatedServerKey = convertToEntity(serverKeyDto);
        updatedServerKey.setId(id);
        updatedServerKey.setCreatedAt(existingServerKey.getCreatedAt());
        updatedServerKey.setUpdatedAt(LocalDateTime.now());

        serverKeyMapper.update(updatedServerKey);
        
        return convertToDto(updatedServerKey);
    }

    @Override
    public boolean deleteServerKey(Long id) {
        ServerKey serverKey = serverKeyMapper.selectById(id);
        if (serverKey == null) {
            return false;
        }
        
        int result = serverKeyMapper.deleteById(id);
        return result > 0;
    }

    @Override
    public ServerKeyDto refreshServerKey(Long id) {
        ServerKey serverKey = serverKeyMapper.selectById(id);
        if (serverKey == null) {
            return null;
        }
        
        // 生成新的密钥
        serverKey.setKey(generateUniqueKey());
        serverKey.setUpdatedAt(LocalDateTime.now());
        
        serverKeyMapper.update(serverKey);
        
        return convertToDto(serverKey);
    }

    /**
     * 生成唯一的密钥
     */
    private String generateUniqueKey() {
        String key;
        boolean keyExists;
        
        do {
            key = UUID.randomUUID().toString().replace("-", "");
            ServerKey existingKey = serverKeyMapper.selectByKey(key);
            keyExists = existingKey != null;
        } while (keyExists);
        
        return key;
    }

    /**
     * 将实体转换为DTO
     */
    private ServerKeyDto convertToDto(ServerKey serverKey) {
        ServerKeyDto dto = new ServerKeyDto();
        dto.setId(serverKey.getId());
        dto.setKey(serverKey.getKey());
        dto.setServerUuid(serverKey.getServerUuid());
        dto.setName(serverKey.getName());
        dto.setDescription(serverKey.getDescription());
        dto.setServerName(serverKey.getServerName());
        dto.setServerIp(serverKey.getServerIp());
        dto.setServerPort(serverKey.getServerPort());
        dto.setCreatedAt(serverKey.getCreatedAt());
        dto.setUpdatedAt(serverKey.getUpdatedAt());
        return dto;
    }

    /**
     * 将DTO转换为实体
     */
    private ServerKey convertToEntity(ServerKeyDto dto) {
        ServerKey entity = new ServerKey();
        entity.setId(dto.getId());
        entity.setKey(dto.getKey());
        entity.setServerUuid(dto.getServerUuid());
        entity.setName(dto.getName());
        entity.setDescription(dto.getDescription());
        entity.setServerName(dto.getServerName());
        entity.setServerIp(dto.getServerIp());
        entity.setServerPort(dto.getServerPort());
        entity.setCreatedAt(dto.getCreatedAt());
        entity.setUpdatedAt(dto.getUpdatedAt());
        return entity;
    }
} 